Interactive Maps with Leaflet in R

This document provides a comprehensive guide to creating interactive maps using the leaflet package in R. We will explore various features of leaflet, from basic map creation to advanced customizations like adding markers, popups, and choropleth layers. This guide is intended for users who have a basic understanding of R and are interested in data visualization and geospatial analysis.

1 Getting Started: Loading Libraries and Data

First, we need to load the necessary R libraries. We’ll be using tidyverse for data manipulation, sf for working with spatial data, leaflet for creating the maps, and geojsonio for reading GeoJSON files.

# Load the tidyverse package for data manipulation and visualization.
library(tidyverse)

# Load the sf package for working with simple features, a standardized way to encode spatial vector data.
library(sf)
# Load the leaflet package for creating interactive maps.
library(leaflet)
# Load the geojsonio package for reading and writing GeoJSON.
library(geojsonio)
# Load the leaflet.extras package for additional leaflet features.
library(leaflet.extras)

2 Displaying a Basic Map with OpenStreetMap

Here, we’ll create a simple map using the default OpenStreetMap tiles and add a marker for a specific location.

# Create a leaflet map widget.
m <- leaflet() %>%
   # Add the default OpenStreetMap map tiles.
  addTiles() %>%
  # Add a marker to the map at the specified longitude and latitude.
  addMarkers(lng=174.768, lat=-36.852, popup="The birthplace of R")

# Display the map.
m

3 Using Google Maps as a Basemap

Instead of the default OpenStreetMap, you can use other tile providers like Google Maps.

leaflet() |>
  # Add Google Maps tiles using the specified URL template.
  addTiles(urlTemplate = "https://mt1.google.com/vt/lyrs=m&x={x}&y={y}&z={z}") |>
  # Set the initial view of the map with a specific center and zoom level.
  setView(116.347817690225, 39.997202126977, zoom = 16) |>
  # Add a marker to the map.
  addMarkers(116.347817690225, 39.997202126977)

4 Using Third-Party Map Providers

Leaflet supports a wide variety of third-party map providers. You can find a list of available providers in the providers object.

# You can uncomment these lines to try a different map provider.
# m <- leaflet() %>% setView(lng = -71.0589, lat = 42.3601, zoom = 10)
# m %>% addProviderTiles(providers$Stadia.StamenToner)

5 Adding Popups

Popups are small boxes containing arbitrary HTML that point to a specific point on the map.

# Create HTML content for the popup.
content <- paste(sep = "<br/>",
  "<b><a href='https://www.samurainoodle.com/'>Samurai Noodle</a></b>",
  "606 5th Ave. S",
  "Seattle, WA 98138"
)

# Create a map and add a popup.
leaflet() %>% addTiles() %>%
  setView(-122.327298, 47.597131,zoom = 12) %>%
  addPopups(-122.327298, 47.597131, content,
    # You can customize the popup options, for example, to remove the close button.
    options = popupOptions(closeButton = FALSE)
  )

6 Adding Markers from a Data Frame

You can add multiple markers to a map from a data frame.

# Load the htmltools package for working with HTML.
library(htmltools)

# Create a data frame with marker information.
df <- read.csv(textConnection(
"Name,Lat,Long
Samurai Noodle,47.597131,-122.327298
Kukai Ramen,47.6154,-122.327157
Tsukushinbo,47.59987,-122.326726"
))

# Create a map and add markers from the data frame.
leaflet(df) %>% addTiles() %>%
  addMarkers(~Long, ~Lat, popup = ~htmlEscape(Name))

7 Adding Labels

Labels are similar to popups but are always displayed or displayed on mouseover.

# Load the htmltools package.
library(htmltools)

# Create a data frame with marker information.
df <- read.csv(textConnection(
"Name,Lat,Long
Samurai Noodle,47.597131,-122.327298
Kukai Ramen,47.6154,-122.327157
Tsukushinbo,47.59987,-122.326726"))

# Create a map and add markers with labels.
leaflet(df) %>% addTiles() %>%
  addMarkers(~Long, ~Lat, label = ~htmlEscape(Name))

8 Creating a World Choropleth Map

Now, let’s create a choropleth map of the world, where countries are colored based on their per capita GDP.

8.1 Loading Geospatial and GDP Data

We’ll start by loading the world administrative boundaries from a GeoJSON file and then merge it with per capita GDP data from an Excel file.

# The maptools package is now archived, so we are not using it.
# install.packages("https://cran.r-project.org/src/contrib/Archive/maptools/maptools_1.1-8.tar.gz")

# Read the world administrative boundaries from a GeoJSON file.
json_data=read_sf("world-administrative-boundaries.geojson")

# Convert the sf object to a data frame.
map_df <- as.data.frame(json_data)

# This is an example of how you could create a data frame manually.
# name<-c("Ghana", "Grenada", "Guyana", "India", "Jamaica", "Kenya", "United States","Canada")
# val<-c(1,2,4,5,5,1000,20000, 100)
# per_gdp_usd<-data.frame(name,val)

# Load the openxlsx and readxl packages for reading Excel files.
library(openxlsx)
library(readxl)

# Read the world GDP data from an Excel file and clean up the country names to match the GeoJSON data.
per_gdp_usd=read_excel('world data.xlsx') %>% mutate(
  name=case_when(
    name == "United States" ~ "United States of America",
    name == "Russia" ~ "Russian Federation",
    name == "U.K. of Great Britain and Northern Ireland" ~ "United Kingdom",
    name == "South Korea"~ "Republic of Korea",
    name == "Lao People's Democratic Republic" ~ "Laos",
    TRUE ~ name
  )
)

8.2 Merging and Preparing the Data

We’ll merge the geospatial data with the GDP data and convert it back to an sf object.

# These lines are for debugging and checking the data.
# test=full_join(map_df, per_gdp_usd, by="name")
# left =test %>% filter(is.na(iso3)==TRUE)
# right=test %>% filter(is.na(per_gdp_total)==TRUE)

# Merge the map data frame with the GDP data frame by country name.
map_df002 <- merge(map_df, per_gdp_usd, by.x = "name", by.y = "name")

# Get a glimpse of the merged data frame.
glimpse(map_df002)

Rows: 158
Columns: 12
$ name                     <chr> "Albania", "Algeria", "Andorra", "Angola", "A…
$ geo_point_2d             <chr> "{ \"lon\": 20.068384605918776, \"lat\": 41.1…
$ iso3                     <chr> "ALB", "DZA", "AND", "AGO", "ARG", "ARM", "AU…
$ status                   <chr> "Member State", "Member State", "Member State…
$ color_code               <chr> "ALB", "DZA", "AND", "AGO", "ARG", "ARM", "AU…
$ continent                <chr> "Europe", "Africa", "Europe", "Africa", "Amer…
$ region                   <chr> "Southern Europe", "Northern Africa", "Southe…
$ iso_3166_1_alpha_2_codes <chr> "AL", "DZ", "AD", "AO", "AR", "AM", "AU", "AT…
$ french_short             <chr> "Albanie", "Algérie", "Andorre", "Angola", "A…
$ geometry                 <MULTIPOLYGON [°]> MULTIPOLYGON (((20.07142 42..., …
$ per_gdp_total            <dbl> 1.888210e+10, 1.919130e+11, 3.352033e+09, 1.0…
$ per_gdp_usd              <dbl> 6643, 4274, 41993, 2999, 13904, 7014, 64003, …

# Convert the merged data frame back to an sf object.
map_sf002 <- sf::st_as_sf(map_df002, sf_column_name = "geometry")

8.3 Creating the Choropleth Map

Now we can create the choropleth map.

# Create a color palette for the choropleth map.
pal <- colorNumeric("viridis", NULL)

# Create the leaflet map.
leaflet(map_sf002) %>%
  addTiles() %>%
  # Add polygons to the map, representing the countries.
  addPolygons(smoothFactor = 0.3, fillOpacity = 0.5,weight = 1,
    # Set the fill color based on the per capita GDP.
    fillColor = ~ pal(per_gdp_usd),
    # Create a popup with information about the country.
    popup = ~ paste0(
      "地区：", name, "<br/>",
      "<hr/>",
      "人均gpd：", per_gdp_usd, "（千 美元）", "<br/>"
    ),
    # Create a label with more detailed information.
     label = lapply(paste0(
      "地区：", "<b>", map_sf002$name, "</b>", "<br/>",
      "人均gpd 美元：", round(map_sf002$per_gdp_usd/1000), "K <br/>",
       "总gpd 美元：", round(map_sf002$per_gdp_total/1000000), "M <br/>"
    ), htmltools::HTML)
    ) %>%
  # Add a legend to the map.
  addLegend(
    position = "bottomright", title = "人均gpd(美元)",
    pal = pal, values = ~per_gdp_usd, opacity = 1.0
    )

9 China Maps

Now we will create several maps of China, including a map of a single city, a choropleth map of all provinces, and a map of a single province with its cities.

9.1 China One City Map (Shenzhen)

Here, we’ll create a map of Shenzhen.

# Read the GeoJSON data for Shenzhen.
json_data <- sf::read_sf("./GeoMapData_CN/citys/440300.json")
# You can also load the data directly from a URL.
# json_data=read_sf("https://geo.datav.aliyun.com/areas_v2/bound/440300_full.json")

Shenzhen City:

# Create a color palette.
pal <- colorNumeric("viridis", NULL)

# Create the map of Shenzhen.
leaflet(json_data) %>%
  addTiles() %>%
  addPolygons(smoothFactor = 0.3, fillOpacity = 0.1)

9.2 All China Each Province GDP Map

Next, we’ll create a choropleth map of China’s provinces, colored by their per capita GDP in 2022.

# Read the GeoJSON data for China's provinces.
json_data=read_sf("https://geo.datav.aliyun.com/areas_v2/bound/100000_full.json")

China 2022 Per Capita GDP by Province (USD):

# Load the openxlsx and readxl packages.
library(openxlsx)
library(readxl)
# Read the GDP data for China's provinces.
per_gdp_usd=read_excel('china gdp2022.xlsx')

# Convert the sf object to a data frame.
map_df <- as.data.frame(json_data)

# Merge the map data with the GDP data.
map_df002 <- merge(map_df, per_gdp_usd, by.x = "name", by.y = "city")

# Convert the merged data frame back to an sf object.
map_sf002 <- sf::st_as_sf(map_df002, sf_column_name = "geometry")

# Create a color palette.
pal <- colorNumeric("viridis", NULL)

# Create the choropleth map of China's provinces.
leaflet(map_sf002) %>%
  addTiles() %>%
  addPolygons(smoothFactor = 0.3, fillOpacity = 0.5,weight = 1,
    fillColor = ~ pal(per_gpd_usd),
    popup = ~ paste0(
      "地区：", name, "<br/>",
      "<hr/>",
      "人均gpd：", per_gpd_usd, "（美万）", "<br/>"
    ),
     label = lapply(paste0(
      "地区：", "<b>", map_sf002$name, "</b>", "<br/>",
      "人均gpd 美元：", map_sf002$per_gpd_usd, "<br/>",
      "人均gpd 人民币：", map_sf002$per_gpd_rmb, "<br/>",
       "人口：", round(map_sf002$total_gpd_rmb/map_sf002$per_gpd_rmb), "<br/>"
    ), htmltools::HTML)
    ) %>% addLegend(
    position = "bottomright", title = "人均gpd(美元)",
    pal = pal, values = ~per_gpd_usd, opacity = 1.0
    )

GDP data source: National Bureau of Statistics of China

9.3 China One Province Map with Each City’s GDP (Guangdong)

Here, we’ll create a choropleth map of Guangdong province, with each city colored by its per capita GDP in 2021.

# Read the GeoJSON data for Guangdong province.
json_data <- sf::read_sf("./GeoMapData_CN/province/440000.json")

Guangdong 2021 Per Capita GDP by City (USD):

# Load the openxlsx and readxl packages.
library(openxlsx)
library(readxl)
# Read the GDP data for Guangdong's cities.
per_gdp_usd=read_excel('guangdong city gdp2021.xlsx')

# Convert the sf object to a data frame.
map_df <- as.data.frame(json_data)

# Merge the map data with the GDP data.
map_df002 <- merge(map_df, per_gdp_usd, by.x = "name", by.y = "city")

# Convert the merged data frame back to an sf object.
map_sf002 <- sf::st_as_sf(map_df002, sf_column_name = "geometry")

Data source: Guangdong Statistical Yearbook 2022

# Create a color palette.
pal <- colorNumeric("viridis", NULL)

# Create the choropleth map of Guangdong province.
leaflet(map_sf002) %>%
  addTiles() %>%
  addPolygons(smoothFactor = 0.3, fillOpacity = 0.5,weight = 1,
    fillColor = ~ pal(per_gpd_usd),
    popup = ~ paste0(
      "城市：", name, "<br/>",
      "<hr/>",
      "人均gpd：", per_gpd_usd, "（美万）", "<br/>"
    ),
     label = lapply(paste0(
      "城市：", "<b>", map_sf002$name, "</b>", "<br/>",
      "人均gpd 美元：", map_sf002$per_gpd_usd, "<br/>",
      "人均gpd 人民币：", map_sf002$per_gpd_rmb, "<br/>",
       "人口：", round(map_sf002$total_gpd_rmb*10000000/map_sf002$per_gpd_rmb), "<br/>"
    ), htmltools::HTML)
    ) %>% addLegend(
    position = "bottomright", title = "人均gpd(美元)",
    pal = pal, values = ~per_gpd_usd, opacity = 1.0
    )

https://zh.wikipedia.org/wiki/%E5%B9%BF%E4%B8%9C%E5%90%84%E5%9C%B0%E7%BA%A7%E5%B8%82%E5%9C%B0%E5%8C%BA%E7%94%9F%E4%BA%A7%E6%80%BB%E5%80%BC%E5%88%97%E8%A1%A8

10 China Province Map

This section shows how to create a simple map of China’s provinces and add markers for the provincial capitals.

# Load the leaflet and sf packages.
library(leaflet)
library(sf)

# Read the GeoJSON data for China's provinces.
json_data <- sf::read_sf("./GeoMapData_CN/china.json")
# You can also load the data from a URL.
# json_data=read_sf("https://geo.datav.aliyun.com/areas_v2/bound/100000_full.json")

# Create a color palette.
pal <- colorNumeric("viridis", NULL)

# Create the map of China's provinces.
m=leaflet(json_data) %>%
  addTiles() %>%
  addPolygons(smoothFactor = 0.3, fillOpacity = 0.1)

# Display the map.
m

10.1 Add Provincial Capitals

Now, let’s add the provincial capitals to the map.

# Read the GeoJSON data for China's provinces.
China=read_sf("https://geo.datav.aliyun.com/areas_v2/bound/100000_full.json")

# Extract the coordinates of the provincial capitals.
China002=China %>% as_data_frame() %>% mutate(
                                            center2=as.character(center) %>% str_replace('c','_')%>% str_replace('[(]','') %>% str_replace('[)]','')
                                               )

# Separate the coordinates into x and y columns.
China003=China002%>%separate(center2, c("x", "y"), ", ")

# Add the provincial capitals to the map.
China_point = China003 %>%
  slice(-35)

m %>%
  addCircles(data = China_point,
                  lng = ~as.numeric(x), lat = ~as.numeric(y),color = "red",weight = 10,
                  fillOpacity =2)

11 China Province and City Map

This section demonstrates how to load and combine GeoJSON files for all provinces and their cities.

# Get a list of all province GeoJSON files.
map_list <- lapply(
  X = list.files("./GeoMapData_CN/province", recursive = T, full.names = T),
  FUN = sf::read_sf
)

# Print the number of files.
length(map_list)

[1] 34

# Check for any files that don't have 10 columns.
for (i in c(1:length(map_list))){
   #print(i)
  #print(dim(map_list[[i]]))
  #print(ncol(map_list[[i]]))
  if(ncol(map_list[[i]])!=10){print(map_list[[i]])}
  }

Simple feature collection with 1 feature and 4 fields
Geometry type: MULTIPOLYGON
Dimension:     XY
Bounding box:  xmin: 119.3183 ymin: 21.75147 xmax: 124.5656 ymax: 25.92592
Geodetic CRS:  WGS 84
# A tibble: 1 × 5
  adcode name   center               level                              geometry
  <chr>  <chr>  <chr>                <chr>                    <MULTIPOLYGON [°]>
1 710000 台湾省 121.509062,25.044332 province (((119.5543 23.68248, 119.555 23.…

# Exclude some problematic files.
X = list.files("./GeoMapData_CN/province", recursive = T, full.names = T)
X2=X[-which(X %in% c("./GeoMapData_CN/province/710000.json"
         ))]

# Reload the list of files.
map_list <- lapply(
  X = X2,
  FUN = sf::read_sf
)

# Print the number of files.
length(map_list)

[1] 33

# Combine all the sf objects into one.
province_map <- Reduce("rbind", map_list)

# This code would display the combined map.
# library(leaflet)
# library(sf)
#
# json_data <- province_map
#
#
# pal <- colorNumeric(c("red", "green", "blue"), 1:10)
#
# leaflet(json_data) %>%
#   addTiles() %>%
#   addPolygons(smoothFactor = 0.3, fillOpacity = 0.1)

12 China City and District Map

This section is similar to the previous one, but it loads GeoJSON files for cities and their districts.

# Get a list of all city GeoJSON files.
map_list <- lapply(
  X = list.files("./GeoMapData_CN/citys", recursive = T, full.names = T),
  FUN = sf::read_sf
)

# Print the number of files.
length(map_list)

[1] 334

# Check for any files that don't have 10 columns.
for (i in c(1:length(map_list))){
   #print(i)
  #print(dim(map_list[[i]]))
  #print(ncol(map_list[[i]]))
  if(ncol(map_list[[i]])!=10){print(map_list[[i]])}
  }

Simple feature collection with 1 feature and 4 fields
Geometry type: POLYGON
Dimension:     XY
Bounding box:  xmin: 113.5215 ymin: 22.65421 xmax: 114.2603 ymax: 23.14205
Geodetic CRS:  WGS 84
# A tibble: 1 × 5
  adcode name   center               level                              geometry
  <chr>  <chr>  <chr>                <chr>                         <POLYGON [°]>
1 441900 东莞市 113.746262,23.046237 city  ((114.2292 22.81251, 114.2278 22.813…
Simple feature collection with 1 feature and 4 fields
Geometry type: POLYGON
Dimension:     XY
Bounding box:  xmin: 113.157 ymin: 22.20104 xmax: 113.692 ymax: 22.7726
Geodetic CRS:  WGS 84
# A tibble: 1 × 5
  adcode name   center               level                              geometry
  <chr>  <chr>  <chr>                <chr>                         <POLYGON [°]>
1 442000 中山市 113.382391,22.521113 city  ((113.5687 22.41193, 113.5666 22.412…
Simple feature collection with 1 feature and 4 fields
Geometry type: MULTIPOLYGON
Dimension:     XY
Bounding box:  xmin: 115.9267 ymin: 20.58265 xmax: 116.9338 ymax: 21.12693
Geodetic CRS:  WGS 84
# A tibble: 1 × 5
  adcode name     center               level                            geometry
  <chr>  <chr>    <chr>                <chr>                  <MULTIPOLYGON [°]>
1 442100 东沙群岛 116.887312,20.617512 city  (((115.9433 21.09745, 115.95 21.11…
Simple feature collection with 1 feature and 4 fields
Geometry type: MULTIPOLYGON
Dimension:     XY
Bounding box:  xmin: 108.9287 ymin: 19.17894 xmax: 109.7694 ymax: 19.92575
Geodetic CRS:  WGS 84
# A tibble: 1 × 5
  adcode name   center               level                              geometry
  <chr>  <chr>  <chr>                <chr>                    <MULTIPOLYGON [°]>
1 460400 儋州市 109.576782,19.517486 city  (((109.4322 19.91302, 109.4253 19.91…
Simple feature collection with 1 feature and 4 fields
Geometry type: MULTIPOLYGON
Dimension:     XY
Bounding box:  xmin: 97.8483 ymin: 39.65426 xmax: 98.52018 ymax: 39.99979
Geodetic CRS:  WGS 84
# A tibble: 1 × 5
  adcode name     center              level                             geometry
  <chr>  <chr>    <chr>               <chr>                   <MULTIPOLYGON [°]>
1 620200 嘉峪关市 98.277304,39.786529 city  (((97.85974 39.7169, 97.85827 39.71…

# Exclude some problematic files.
X = list.files("./GeoMapData_CN/citys", recursive = T, full.names = T)
X2=X[-which(X %in% c("./GeoMapData_CN/citys/620200.json",
         "./GeoMapData_CN/citys/460400.json",
              "./GeoMapData_CN/citys/442100.json",
              "./GeoMapData_CN/citys/442000.json",
              "./GeoMapData_CN/citys/441900.json"
         ))]

# Reload the list of files.
map_list <- lapply(
  X = X2,
  FUN = sf::read_sf
)

# Print the number of files.
length(map_list)

[1] 329

# Combine all the sf objects into one.
province_map <- Reduce("rbind", map_list)

# This code would display the combined map.
# library(leaflet)
# library(sf)
#
# json_data <- province_map
#
#
# pal <- colorNumeric(c("red", "green", "blue"), 1:10)
#
# leaflet(json_data) %>%
#   addTiles() %>%
#   addPolygons(smoothFactor = 0.3, fillOpacity = 0.1)

13 Displaying All Map Providers

This section shows how to list all available map providers in the leaflet package.

# Display the list of available map providers.
providers

providers

$OpenStreetMap
[1] "OpenStreetMap"

$OpenStreetMap.Mapnik
[1] "OpenStreetMap.Mapnik"

$OpenStreetMap.DE
[1] "OpenStreetMap.DE"

$OpenStreetMap.CH
[1] "OpenStreetMap.CH"

$OpenStreetMap.France
[1] "OpenStreetMap.France"

$OpenStreetMap.HOT
[1] "OpenStreetMap.HOT"

$OpenStreetMap.BZH
[1] "OpenStreetMap.BZH"

$MapTilesAPI
[1] "MapTilesAPI"

$MapTilesAPI.OSMEnglish
[1] "MapTilesAPI.OSMEnglish"

$MapTilesAPI.OSMFrancais
[1] "MapTilesAPI.OSMFrancais"

$MapTilesAPI.OSMEspagnol
[1] "MapTilesAPI.OSMEspagnol"

$OpenSeaMap
[1] "OpenSeaMap"

$OPNVKarte
[1] "OPNVKarte"

$OpenTopoMap
[1] "OpenTopoMap"

$OpenRailwayMap
[1] "OpenRailwayMap"

$OpenFireMap
[1] "OpenFireMap"

$SafeCast
[1] "SafeCast"

$Stadia
[1] "Stadia"

$Stadia.AlidadeSmooth
[1] "Stadia.AlidadeSmooth"

$Stadia.AlidadeSmoothDark
[1] "Stadia.AlidadeSmoothDark"

$Stadia.OSMBright
[1] "Stadia.OSMBright"

$Stadia.Outdoors
[1] "Stadia.Outdoors"

$Stadia.StamenToner
[1] "Stadia.StamenToner"

$Stadia.StamenTonerBackground
[1] "Stadia.StamenTonerBackground"

$Stadia.StamenTonerLines
[1] "Stadia.StamenTonerLines"

$Stadia.StamenTonerLabels
[1] "Stadia.StamenTonerLabels"

$Stadia.StamenTonerLite
[1] "Stadia.StamenTonerLite"

$Stadia.StamenWatercolor
[1] "Stadia.StamenWatercolor"

$Stadia.StamenTerrain
[1] "Stadia.StamenTerrain"

$Stadia.StamenTerrainBackground
[1] "Stadia.StamenTerrainBackground"

$Stadia.StamenTerrainLabels
[1] "Stadia.StamenTerrainLabels"

$Stadia.StamenTerrainLines
[1] "Stadia.StamenTerrainLines"

$Thunderforest
[1] "Thunderforest"

$Thunderforest.OpenCycleMap
[1] "Thunderforest.OpenCycleMap"

$Thunderforest.Transport
[1] "Thunderforest.Transport"

$Thunderforest.TransportDark
[1] "Thunderforest.TransportDark"

$Thunderforest.SpinalMap
[1] "Thunderforest.SpinalMap"

$Thunderforest.Landscape
[1] "Thunderforest.Landscape"

$Thunderforest.Outdoors
[1] "Thunderforest.Outdoors"

$Thunderforest.Pioneer
[1] "Thunderforest.Pioneer"

$Thunderforest.MobileAtlas
[1] "Thunderforest.MobileAtlas"

$Thunderforest.Neighbourhood
[1] "Thunderforest.Neighbourhood"

$CyclOSM
[1] "CyclOSM"

$Jawg
[1] "Jawg"

$Jawg.Streets
[1] "Jawg.Streets"

$Jawg.Terrain
[1] "Jawg.Terrain"

$Jawg.Sunny
[1] "Jawg.Sunny"

$Jawg.Dark
[1] "Jawg.Dark"

$Jawg.Light
[1] "Jawg.Light"

$Jawg.Matrix
[1] "Jawg.Matrix"

$MapBox
[1] "MapBox"

$MapTiler
[1] "MapTiler"

$MapTiler.Streets
[1] "MapTiler.Streets"

$MapTiler.Basic
[1] "MapTiler.Basic"

$MapTiler.Bright
[1] "MapTiler.Bright"

$MapTiler.Pastel
[1] "MapTiler.Pastel"

$MapTiler.Positron
[1] "MapTiler.Positron"

$MapTiler.Hybrid
[1] "MapTiler.Hybrid"

$MapTiler.Toner
[1] "MapTiler.Toner"

$MapTiler.Topo
[1] "MapTiler.Topo"

$MapTiler.Voyager
[1] "MapTiler.Voyager"

$TomTom
[1] "TomTom"

$TomTom.Basic
[1] "TomTom.Basic"

$TomTom.Hybrid
[1] "TomTom.Hybrid"

$TomTom.Labels
[1] "TomTom.Labels"

$Esri
[1] "Esri"

$Esri.WorldStreetMap
[1] "Esri.WorldStreetMap"

$Esri.DeLorme
[1] "Esri.DeLorme"

$Esri.WorldTopoMap
[1] "Esri.WorldTopoMap"

$Esri.WorldImagery
[1] "Esri.WorldImagery"

$Esri.WorldTerrain
[1] "Esri.WorldTerrain"

$Esri.WorldShadedRelief
[1] "Esri.WorldShadedRelief"

$Esri.WorldPhysical
[1] "Esri.WorldPhysical"

$Esri.OceanBasemap
[1] "Esri.OceanBasemap"

$Esri.NatGeoWorldMap
[1] "Esri.NatGeoWorldMap"

$Esri.WorldGrayCanvas
[1] "Esri.WorldGrayCanvas"

$OpenWeatherMap
[1] "OpenWeatherMap"

$OpenWeatherMap.Clouds
[1] "OpenWeatherMap.Clouds"

$OpenWeatherMap.CloudsClassic
[1] "OpenWeatherMap.CloudsClassic"

$OpenWeatherMap.Precipitation
[1] "OpenWeatherMap.Precipitation"

$OpenWeatherMap.PrecipitationClassic
[1] "OpenWeatherMap.PrecipitationClassic"

$OpenWeatherMap.Rain
[1] "OpenWeatherMap.Rain"

$OpenWeatherMap.RainClassic
[1] "OpenWeatherMap.RainClassic"

$OpenWeatherMap.Pressure
[1] "OpenWeatherMap.Pressure"

$OpenWeatherMap.PressureContour
[1] "OpenWeatherMap.PressureContour"

$OpenWeatherMap.Wind
[1] "OpenWeatherMap.Wind"

$OpenWeatherMap.Temperature
[1] "OpenWeatherMap.Temperature"

$OpenWeatherMap.Snow
[1] "OpenWeatherMap.Snow"

$HERE
[1] "HERE"

$HERE.normalDay
[1] "HERE.normalDay"

$HERE.normalDayCustom
[1] "HERE.normalDayCustom"

$HERE.normalDayGrey
[1] "HERE.normalDayGrey"

$HERE.normalDayMobile
[1] "HERE.normalDayMobile"

$HERE.normalDayGreyMobile
[1] "HERE.normalDayGreyMobile"

$HERE.normalDayTransit
[1] "HERE.normalDayTransit"

$HERE.normalDayTransitMobile
[1] "HERE.normalDayTransitMobile"

$HERE.normalDayTraffic
[1] "HERE.normalDayTraffic"

$HERE.normalNight
[1] "HERE.normalNight"

$HERE.normalNightMobile
[1] "HERE.normalNightMobile"

$HERE.normalNightGrey
[1] "HERE.normalNightGrey"

$HERE.normalNightGreyMobile
[1] "HERE.normalNightGreyMobile"

$HERE.normalNightTransit
[1] "HERE.normalNightTransit"

$HERE.normalNightTransitMobile
[1] "HERE.normalNightTransitMobile"

$HERE.reducedDay
[1] "HERE.reducedDay"

$HERE.reducedNight
[1] "HERE.reducedNight"

$HERE.basicMap
[1] "HERE.basicMap"

$HERE.mapLabels
[1] "HERE.mapLabels"

$HERE.trafficFlow
[1] "HERE.trafficFlow"

$HERE.carnavDayGrey
[1] "HERE.carnavDayGrey"

$HERE.hybridDay
[1] "HERE.hybridDay"

$HERE.hybridDayMobile
[1] "HERE.hybridDayMobile"

$HERE.hybridDayTransit
[1] "HERE.hybridDayTransit"

$HERE.hybridDayGrey
[1] "HERE.hybridDayGrey"

$HERE.hybridDayTraffic
[1] "HERE.hybridDayTraffic"

$HERE.pedestrianDay
[1] "HERE.pedestrianDay"

$HERE.pedestrianNight
[1] "HERE.pedestrianNight"

$HERE.satelliteDay
[1] "HERE.satelliteDay"

$HERE.terrainDay
[1] "HERE.terrainDay"

$HERE.terrainDayMobile
[1] "HERE.terrainDayMobile"

$HEREv3
[1] "HEREv3"

$HEREv3.normalDay
[1] "HEREv3.normalDay"

$HEREv3.normalDayCustom
[1] "HEREv3.normalDayCustom"

$HEREv3.normalDayGrey
[1] "HEREv3.normalDayGrey"

$HEREv3.normalDayMobile
[1] "HEREv3.normalDayMobile"

$HEREv3.normalDayGreyMobile
[1] "HEREv3.normalDayGreyMobile"

$HEREv3.normalDayTransit
[1] "HEREv3.normalDayTransit"

$HEREv3.normalDayTransitMobile
[1] "HEREv3.normalDayTransitMobile"

$HEREv3.normalNight
[1] "HEREv3.normalNight"

$HEREv3.normalNightMobile
[1] "HEREv3.normalNightMobile"

$HEREv3.normalNightGrey
[1] "HEREv3.normalNightGrey"

$HEREv3.normalNightGreyMobile
[1] "HEREv3.normalNightGreyMobile"

$HEREv3.normalNightTransit
[1] "HEREv3.normalNightTransit"

$HEREv3.normalNightTransitMobile
[1] "HEREv3.normalNightTransitMobile"

$HEREv3.reducedDay
[1] "HEREv3.reducedDay"

$HEREv3.reducedNight
[1] "HEREv3.reducedNight"

$HEREv3.basicMap
[1] "HEREv3.basicMap"

$HEREv3.mapLabels
[1] "HEREv3.mapLabels"

$HEREv3.trafficFlow
[1] "HEREv3.trafficFlow"

$HEREv3.carnavDayGrey
[1] "HEREv3.carnavDayGrey"

$HEREv3.hybridDay
[1] "HEREv3.hybridDay"

$HEREv3.hybridDayMobile
[1] "HEREv3.hybridDayMobile"

$HEREv3.hybridDayTransit
[1] "HEREv3.hybridDayTransit"

$HEREv3.hybridDayGrey
[1] "HEREv3.hybridDayGrey"

$HEREv3.pedestrianDay
[1] "HEREv3.pedestrianDay"

$HEREv3.pedestrianNight
[1] "HEREv3.pedestrianNight"

$HEREv3.satelliteDay
[1] "HEREv3.satelliteDay"

$HEREv3.terrainDay
[1] "HEREv3.terrainDay"

$HEREv3.terrainDayMobile
[1] "HEREv3.terrainDayMobile"

$FreeMapSK
[1] "FreeMapSK"

$MtbMap
[1] "MtbMap"

$CartoDB
[1] "CartoDB"

$CartoDB.Positron
[1] "CartoDB.Positron"

$CartoDB.PositronNoLabels
[1] "CartoDB.PositronNoLabels"

$CartoDB.PositronOnlyLabels
[1] "CartoDB.PositronOnlyLabels"

$CartoDB.DarkMatter
[1] "CartoDB.DarkMatter"

$CartoDB.DarkMatterNoLabels
[1] "CartoDB.DarkMatterNoLabels"

$CartoDB.DarkMatterOnlyLabels
[1] "CartoDB.DarkMatterOnlyLabels"

$CartoDB.Voyager
[1] "CartoDB.Voyager"

$CartoDB.VoyagerNoLabels
[1] "CartoDB.VoyagerNoLabels"

$CartoDB.VoyagerOnlyLabels
[1] "CartoDB.VoyagerOnlyLabels"

$CartoDB.VoyagerLabelsUnder
[1] "CartoDB.VoyagerLabelsUnder"

$HikeBike
[1] "HikeBike"

$HikeBike.HikeBike
[1] "HikeBike.HikeBike"

$HikeBike.HillShading
[1] "HikeBike.HillShading"

$BasemapAT
[1] "BasemapAT"

$BasemapAT.basemap
[1] "BasemapAT.basemap"

$BasemapAT.grau
[1] "BasemapAT.grau"

$BasemapAT.overlay
[1] "BasemapAT.overlay"

$BasemapAT.terrain
[1] "BasemapAT.terrain"

$BasemapAT.surface
[1] "BasemapAT.surface"

$BasemapAT.highdpi
[1] "BasemapAT.highdpi"

$BasemapAT.orthofoto
[1] "BasemapAT.orthofoto"

$nlmaps
[1] "nlmaps"

$nlmaps.standaard
[1] "nlmaps.standaard"

$nlmaps.pastel
[1] "nlmaps.pastel"

$nlmaps.grijs
[1] "nlmaps.grijs"

$nlmaps.water
[1] "nlmaps.water"

$nlmaps.luchtfoto
[1] "nlmaps.luchtfoto"

$NASAGIBS
[1] "NASAGIBS"

$NASAGIBS.ModisTerraTrueColorCR
[1] "NASAGIBS.ModisTerraTrueColorCR"

$NASAGIBS.ModisTerraBands367CR
[1] "NASAGIBS.ModisTerraBands367CR"

$NASAGIBS.ViirsEarthAtNight2012
[1] "NASAGIBS.ViirsEarthAtNight2012"

$NASAGIBS.ModisTerraLSTDay
[1] "NASAGIBS.ModisTerraLSTDay"

$NASAGIBS.ModisTerraSnowCover
[1] "NASAGIBS.ModisTerraSnowCover"

$NASAGIBS.ModisTerraAOD
[1] "NASAGIBS.ModisTerraAOD"

$NASAGIBS.ModisTerraChlorophyll
[1] "NASAGIBS.ModisTerraChlorophyll"

$NLS
[1] "NLS"

$JusticeMap
[1] "JusticeMap"

$JusticeMap.income
[1] "JusticeMap.income"

$JusticeMap.americanIndian
[1] "JusticeMap.americanIndian"

$JusticeMap.asian
[1] "JusticeMap.asian"

$JusticeMap.black
[1] "JusticeMap.black"

$JusticeMap.hispanic
[1] "JusticeMap.hispanic"

$JusticeMap.multi
[1] "JusticeMap.multi"

$JusticeMap.nonWhite
[1] "JusticeMap.nonWhite"

$JusticeMap.white
[1] "JusticeMap.white"

$JusticeMap.plurality
[1] "JusticeMap.plurality"

$GeoportailFrance
[1] "GeoportailFrance"

$GeoportailFrance.plan
[1] "GeoportailFrance.plan"

$GeoportailFrance.parcels
[1] "GeoportailFrance.parcels"

$GeoportailFrance.orthos
[1] "GeoportailFrance.orthos"

$OneMapSG
[1] "OneMapSG"

$OneMapSG.Default
[1] "OneMapSG.Default"

$OneMapSG.Night
[1] "OneMapSG.Night"

$OneMapSG.Original
[1] "OneMapSG.Original"

$OneMapSG.Grey
[1] "OneMapSG.Grey"

$OneMapSG.LandLot
[1] "OneMapSG.LandLot"

$USGS
[1] "USGS"

$USGS.USTopo
[1] "USGS.USTopo"

$USGS.USImagery
[1] "USGS.USImagery"

$USGS.USImageryTopo
[1] "USGS.USImageryTopo"

$WaymarkedTrails
[1] "WaymarkedTrails"

$WaymarkedTrails.hiking
[1] "WaymarkedTrails.hiking"

$WaymarkedTrails.cycling
[1] "WaymarkedTrails.cycling"

$WaymarkedTrails.mtb
[1] "WaymarkedTrails.mtb"

$WaymarkedTrails.slopes
[1] "WaymarkedTrails.slopes"

$WaymarkedTrails.riding
[1] "WaymarkedTrails.riding"

$WaymarkedTrails.skating
[1] "WaymarkedTrails.skating"

$OpenAIP
[1] "OpenAIP"

$OpenSnowMap
[1] "OpenSnowMap"

$OpenSnowMap.pistes
[1] "OpenSnowMap.pistes"

$AzureMaps
[1] "AzureMaps"

$AzureMaps.MicrosoftImagery
[1] "AzureMaps.MicrosoftImagery"

$AzureMaps.MicrosoftBaseDarkGrey
[1] "AzureMaps.MicrosoftBaseDarkGrey"

$AzureMaps.MicrosoftBaseRoad
[1] "AzureMaps.MicrosoftBaseRoad"

$AzureMaps.MicrosoftBaseHybridRoad
[1] "AzureMaps.MicrosoftBaseHybridRoad"

$AzureMaps.MicrosoftTerraMain
[1] "AzureMaps.MicrosoftTerraMain"

$AzureMaps.MicrosoftWeatherInfraredMain
[1] "AzureMaps.MicrosoftWeatherInfraredMain"

$AzureMaps.MicrosoftWeatherRadarMain
[1] "AzureMaps.MicrosoftWeatherRadarMain"

$SwissFederalGeoportal
[1] "SwissFederalGeoportal"

$SwissFederalGeoportal.NationalMapColor
[1] "SwissFederalGeoportal.NationalMapColor"

$SwissFederalGeoportal.NationalMapGrey
[1] "SwissFederalGeoportal.NationalMapGrey"

$SwissFederalGeoportal.SWISSIMAGE
[1] "SwissFederalGeoportal.SWISSIMAGE"

14 Session Information

This section provides information about the current R session, including the versions of the loaded packages.

# Display the session information.
sessionInfo()

sessionInfo()

R version 4.5.1 (2025-06-13)
Platform: aarch64-apple-darwin20
Running under: macOS Tahoe 26.1

Matrix products: default
BLAS:   /Library/Frameworks/R.framework/Versions/4.5-arm64/Resources/lib/libRblas.0.dylib 
LAPACK: /Library/Frameworks/R.framework/Versions/4.5-arm64/Resources/lib/libRlapack.dylib;  LAPACK version 3.12.1

locale:
[1] C.UTF-8/C.UTF-8/C.UTF-8/C/C.UTF-8/C.UTF-8

time zone: Asia/Shanghai
tzcode source: internal

attached base packages:
[1] stats     graphics  grDevices utils     datasets  methods   base     

other attached packages:
 [1] readxl_1.4.5         openxlsx_4.2.8       htmltools_0.5.8.1   
 [4] leaflet.extras_2.0.1 geojsonio_0.11.3     leaflet_2.2.2       
 [7] sf_1.0-21            lubridate_1.9.4      forcats_1.0.0       
[10] stringr_1.6.0        dplyr_1.1.4          purrr_1.2.0         
[13] readr_2.1.5          tidyr_1.3.1          tibble_3.3.0        
[16] ggplot2_4.0.0        tidyverse_2.0.0     

loaded via a namespace (and not attached):
 [1] gtable_0.3.6            xfun_0.52               htmlwidgets_1.6.4      
 [4] lattice_0.22-7          tzdb_0.5.0              leaflet.providers_2.0.0
 [7] vctrs_0.6.5             tools_4.5.1             crosstalk_1.2.1        
[10] generics_0.1.4          curl_7.0.0              proxy_0.4-27           
[13] pkgconfig_2.0.3         KernSmooth_2.23-26      RColorBrewer_1.1-3     
[16] S7_0.2.0                lifecycle_1.0.4         compiler_4.5.1         
[19] farver_2.1.2            jqr_1.4.0               class_7.3-23           
[22] yaml_2.3.10             lazyeval_0.2.2          pillar_1.11.1          
[25] jquerylib_0.1.4         classInt_0.4-11         zip_2.3.3              
[28] tidyselect_1.2.1        digest_0.6.37           stringi_1.8.7          
[31] fastmap_1.2.0           grid_4.5.1              cli_3.6.5              
[34] magrittr_2.0.4          utf8_1.2.6              crul_1.5.0             
[37] e1071_1.7-16            withr_3.0.2             scales_1.4.0           
[40] sp_2.2-0                timechange_0.3.0        rmarkdown_2.29         
[43] cellranger_1.1.0        hms_1.1.3               evaluate_1.0.4         
[46] knitr_1.50              V8_6.0.4                viridisLite_0.4.2      
[49] geojson_0.3.5           rlang_1.1.6             Rcpp_1.1.0             
[52] glue_1.8.0              DBI_1.2.3               httpcode_0.3.0         
[55] geojsonsf_2.0.3         jsonlite_2.0.0          R6_2.6.1               
[58] units_0.8-7            

15 Resources

Here are some useful resources for learning more about leaflet and working with geospatial data in R.

https://rstudio.github.io/leaflet/

https://github.com/Lchiffon/leafletCN

https://github.com/longwosion/geojson-map-china

https://xiangyun.rbind.io/2022/02/draw-china-maps/

https://datav.aliyun.com/portal/school/atlas/area_selector